/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package dao;

import dao.exceptions.NonexistentEntityException;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import modelo.Arquivo;
import modelo.Curso;

/**
 *
 * @author Dirac
 */
public class ArquivoJpaController {

    public ArquivoJpaController() {
        emf = DaoManager.getEmf();
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Arquivo arquivo) {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();

            em.persist(arquivo);

            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Arquivo arquivo) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Arquivo persistentArquivo = em.find(Arquivo.class, arquivo.getId());
            Curso cursoOld = persistentArquivo.getCurso();
            Curso cursoNew = arquivo.getCurso();
            if (cursoNew != null) {
                cursoNew = em.getReference(cursoNew.getClass(), cursoNew.getId());
                arquivo.setCurso(cursoNew);
            }
            arquivo = em.merge(arquivo);
            if (cursoOld != null && !cursoOld.equals(cursoNew)) {
                cursoOld.getArquivoCollection().remove(arquivo);
                cursoOld = em.merge(cursoOld);
            }
            if (cursoNew != null && !cursoNew.equals(cursoOld)) {
                cursoNew.getArquivoCollection().add(arquivo);
                cursoNew = em.merge(cursoNew);
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Long id = arquivo.getId();
                if (findArquivo(id) == null) {
                    throw new NonexistentEntityException("The arquivo with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Long id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Arquivo arquivo;
            try {
                arquivo = em.getReference(Arquivo.class, id);
                arquivo.getId();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The arquivo with id " + id + " no longer exists.", enfe);
            }
            Curso curso = arquivo.getCurso();
            if (curso != null) {
                curso.getArquivoCollection().remove(arquivo);
                curso = em.merge(curso);
            }
            em.remove(arquivo);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Arquivo> findArquivoEntities() {
        return findArquivoEntities(true, -1, -1);
    }

    public List<Arquivo> findArquivoEntities(int maxResults, int firstResult) {
        return findArquivoEntities(false, maxResults, firstResult);
    }

    private List<Arquivo> findArquivoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Arquivo as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Arquivo findArquivo(Long id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Arquivo.class, id);
        } finally {
            em.close();
        }
    }

    public int getArquivoCount() {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select count(o) from Arquivo as o");
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

    public List<Arquivo> search(Arquivo arquivo) {
        EntityManager em = getEntityManager();
        try {
        List<Arquivo> listaAux = new ArrayList<Arquivo>();
        List<Arquivo> lista = findArquivoEntities();

        if (arquivo.getId() != null && arquivo.getId() != 0) {
            System.out.println(">>>>>>>>>>>>>>>>>>>>>>ID");
            lista.clear();
            lista.add(findArquivo(arquivo.getId()));
            return lista;
        }

        if (arquivo.getAluno() != null && (!arquivo.getAluno().equals("")) ) {
            System.out.println(">>>>>>>>>>>>>>>>>>>>>>Alunoooo");
            Query query = em.createQuery("SELECT p FROM Arquivo p WHERE p.aluno like :aluno ");
            query.setParameter("aluno", "%" + arquivo.getAluno() + "%");
            System.out.println(query.toString());
            lista = query.getResultList();
        }

        if (arquivo.getRa() != null && (!arquivo.getRa().equals(""))) {
            System.out.println(">>>>>>>>>>>>>>>>>>>>>>RAAAAA");
            for (Arquivo arq : lista) {
                if (arq.getRa() != null && arq.getRa().equals(arquivo.getRa())) {
                    listaAux.add(arq);
                }
            }
            lista = listaAux;
        }

        if (arquivo.getCaixa() != null&& (!arquivo.getCaixa().equals(""))) {
            System.out.println(">>>>>>>>>>>>>>>>>>>>>>Caixaaaaaaa");
            for (Arquivo arq : lista) {
                if (arq.getCaixa().equals(arquivo.getCaixa())) {
                    listaAux.add(arq);
                }
            }
            lista = listaAux;

        }

            return lista;
        } finally {
            em.close();
        }
    }
    
    public List<Arquivo> searchCurso(Curso curso) throws Exception {
        EntityManager em = getEntityManager();
//        try {
            
                        
           
        try {
            Query query = em.createQuery("SELECT p FROM Arquivo p WHERE p.curso = :curso");

            query.setParameter("curso", curso);
            return (List<Arquivo>) query.getResultList();
        } catch (Exception e) {
            throw new Exception();
        
        } finally {
            em.close();
        }
    }
            
            
        
//        List<Arquivo> listaAux = new ArrayList<Arquivo>();
//        List<Arquivo> lista = findArquivoEntities();
//
//        
//        for (Arquivo arq : lista) {
//                if (arq.getCurso()  == curso) {
//                    listaAux.add(arq);
//                }
//            }
//            lista = listaAux;
//        
//        
//
//            return lista;
//        } finally {
//            em.close();
//        }
//    }
}
